
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.border.LineBorder;
import javax.swing.border.TitledBorder;


/**
 * La classe GamePanel estende JPanel ereditando tutte le sue proprietà.
 * Questa classe identifica la parte destra del pannello di gioco all'interno del quale
 * sono contenuti gli elementi fondamentali permettendo al giocatore di poter girare la ruota,
 * giocate il jolly, passare il turno e scegliere una lettera da un elenco distinto in vocali e
 * consonanti. 
 * @author Fabio Duma
 */
public class GamePanel extends JPanel {
    /**
     * Oggetto di tipo JButton che identifica il pulsante per girare la ruota
     */
    private JButton wheelButton;
    /**
     * Oggetto List di tipo String contenente la lista degòo elementi della ruota
     */
    private List<String> probabilites;
    /**
     * Oggetto di tipo JButton che identifica il pulsante del Jolly
     */
    private JButton jollyButton;
    /**
     * Oggetto di tipo JLabel che mostra il risultato ottenuto girando la ruota
     */
    private JLabel JWheel;
    /**
     * Oggetto di tipo ImageIcon contenete l'immagine del jolly
     */
    private ImageIcon jolly;
    /**
     * Oggetto di tipo Random per la scelta casuale del valore della ruota
     */
    private Random random;
/**
 * Costante che identifica la lista delle lettere alfabetiche
 */
    private final Letter[] letters = {new Letter("A",Letter.VOWEL), new Letter("E",Letter.VOWEL),
        new Letter("I",Letter.VOWEL), new Letter("O",Letter.VOWEL), new Letter("U",Letter.VOWEL),new Letter("B",Letter.CONSONANT), new Letter("C",Letter.CONSONANT),
        new Letter("D",Letter.CONSONANT), new Letter("F",Letter.CONSONANT), new Letter("G",Letter.CONSONANT), new Letter("H",Letter.CONSONANT),new Letter("J",Letter.CONSONANT),new Letter("K",Letter.CONSONANT),
        new Letter("L",Letter.CONSONANT), new Letter("M",Letter.CONSONANT), new Letter("N",Letter.CONSONANT), new Letter("P",Letter.CONSONANT),
        new Letter("Q",Letter.CONSONANT), new Letter("R",Letter.CONSONANT), new Letter("S",Letter.CONSONANT), new Letter("T",Letter.CONSONANT),
        new Letter("V",Letter.CONSONANT), new Letter("W",Letter.CONSONANT), new Letter("X",Letter.CONSONANT), new Letter("Y",Letter.CONSONANT),
        new Letter("Z",Letter.CONSONANT)
    };
    /**
     * Oggetto che identifica la lista dei giocatori
     */
    private List<Player> players;
    /**
     * Intero che identifica il turno del giocatore
     */
    private int player;
    /**
     * Costante di tipo intero che identifica il punteggio limite per poter giocare
     * una vocale
     */
    private final int VOWELS_POINT=2000;
    /**
     * Lista di tipo JLabel che identifica un label per ogni singolo carattere della frase
     * da indovinare 
     */
    private List<JLabel> phrases;
    /**
     * Lista di tipo Character che identifica ogni singolo carattere della frase 
     */
    private List<Character> Charphrases;
    /**
     * Oggetto di tipo JButton che identifica il pulsante Passa
     */
    private JButton passButton;
    /**
     * Oggetto di tipo JMenuItem che identifica la voce Salva Gioco dal menu a tendina
     */
    private JMenuItem savegame;
    /**
     * Oggetto di tipo SaveGame per il salvataggio di una partita
     */
    private SaveGame save;
    /**
     * Intero che identifica il numero della manche in svolgimento
     */
    private int game;
    /**
     * Inizializza un nuovo oggetto GamePanel,all'interno del quale vengono impostati
     * tutti i parametri e gli oggetti necessari per creare la condizione di poter giocare la partita
     */
    public GamePanel() {
        // viene inizializzato l'oggetto Random
        random = new Random();
        // viene inizializzato L'ArrayList di tipo Stringa
        probabilites = new ArrayList<String>();
       // viene caricato il metodo setActionListener che imposta l'azione di
        // ogni singolo pulsante lettera
        setActionLetters();

       // il valore player viene impostato a 0
        player=0;
        // viene caricato il metodo DisableLetter che disabilita i pulsanti lettera
         DisableLetter();
    }
/**
 * Metodo per l'inserimento delle probabilità letta dal file xml
 * @param prob Lista di tipo stringa contenente i valori della ruota
 */
    public void setProbabilities(List <String> prob) {
        this.probabilites=prob;
    
    }
/**
 * Imposta il layout del pannello
 */
    public void setLayout() {
        BoxLayout layout = new BoxLayout(this, BoxLayout.Y_AXIS);
        this.setBorder(new LineBorder(Color.LIGHT_GRAY, 1, true));

        this.setLayout(layout);
        // aggiunge a GamePanel il pannello WheelPanel() con al suo interno
        // i pulsanti di gioco
        this.add(WheelPanel());
        // aggiunge a GamePanel il pannello VowelPanel() contenente la lista dei
        // pulsanti lettera relativi alle vocali
        this.add(VowelPanel());
        // aggiunge a GamePanel il pannello ConsonantPanel() contenente la lista
        // dei pulsanti lettera relativi alle consonanti
        this.add(ConsonantPanel());
    }
    /**
     * Ritorna un oggetto di tipo JPanel che identifica il pannello di gioco
     * con al suo interno il label che mostra il valore della ruota giocato ed i
     * pulsanti di gioco ( gira, passa, jolly)
     * @return un JPanel contenente i pulsanti di gioco
     */
    private JPanel WheelPanel() {

        JPanel jp = new JPanel();
        JPanel jp2 = new JPanel();
        jp.setAlignmentX(Component.CENTER_ALIGNMENT);
        jp.setPreferredSize(new Dimension(150, 160));
        // inizializza un nuovo oggetto di tipo ImageIcon caricando l'immagine di jolly
        jolly = new ImageIcon(GamePanel.class.getResource("image/jolly.gif"));
       // inizializza il pulsante Gira
        wheelButton = new JButton("Gira");
        //inizializza il pulsante Passa
        passButton = new JButton("Passa");
        //inizializza il pulsante Jolly
        jollyButton = new JButton(jolly);
        // imposta i margini per addattare le dimensioni del pulsante all'immagine del jolly
        jollyButton.setMargin(new Insets(0,0,0,0));
        // inizializza l'oggetto JLabel che identifica il risultato prodotto dalla ruota
        JWheel = new JLabel("", JLabel.CENTER);
        // imposta il background del Label
        JWheel.setBackground(new Color(255, 255, 255));
        
        JWheel.setOpaque(true);
        // imposta i bordi del label per renderlo più visibile 
        JWheel.setBorder(BorderFactory.createMatteBorder(2, 2, 2, 2, new Color(51, 51, 51)));
        JWheel.setPreferredSize(new Dimension(80, 20));
        // imposta il font del label
        JWheel.setFont(new Font("Monotype Corsiva", 1, 12));
        // centra il valore di stringa all'interno del label
        JWheel.setHorizontalTextPosition(JLabel.CENTER);
        JWheel.setVerticalTextPosition(JLabel.CENTER);
        JWheel.setAlignmentX(Component.CENTER_ALIGNMENT);
        // ordina verticalmente i componenti del pannello
        jp.setLayout(new BoxLayout(jp, BoxLayout.Y_AXIS));
        
        wheelButton.setAlignmentX(Component.CENTER_ALIGNMENT);
        passButton.setAlignmentX(Component.CENTER_ALIGNMENT);
        jollyButton.setAlignmentX(Component.CENTER_ALIGNMENT);
        // disabilita il pulsante jolly
        jollyButton.setEnabled(false);
        // disablita il pulsante passa
        passButton.setEnabled(false);
        // imposta l'azione al pulsante gira
        wheelButton.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                wheelButton_actionPerformed(e);
                
            }
        });
        // imposta l'azione al pulsante jolly
          jollyButton.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                jollyButton_actionPerformed(e);
                
            }
        });
        // imposta l'azione  al pulsante passa
        passButton.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                passButton_actionPerformed(e);
                
            }
        });
        // inserisce il Label dei valori della ruota all'interno del pannello
        jp2.add(JWheel);
        
        jp.add(jp2);
        // inserisce il pulsante gira all'interno del pannello
        jp.add(wheelButton);
        // inserisce il pulsante passa all'interno del pannello
        jp.add(passButton);
        // inserisce il pulsante jolly all'interno del pannello
        jp.add(jollyButton);

        return jp;
    }
    /**
     * Restituisce un oggetto di tipo JPanel che mostra il pannello delle vocali
     * @return un JPanel contenente le vocali
     */
    private JPanel VowelPanel() {

        JPanel jp = new JPanel();

        jp.setBorder(new TitledBorder("Vocali"));
        jp.setPreferredSize(new Dimension(160, 100));
         //scorre la lista delle lettere e nel caso in cui le lettere siano vocali
        // le inserisce all'interno del pannello
        for (int i = 0; i < letters.length; i++) {
            
           // confronta se il tipo di lettera in quella posizione è una vocale
           if(letters[i].getKind()==Letter.VOWEL){

            jp.add(letters[i]);
           }
        }

        return jp;
    }
/**
 * Restituisce un oggetto di tipo JPanel che identifica il pannello delle consonanti
 * @return un JPanel contenente le consonanti
 */
    private JPanel ConsonantPanel() {

        JPanel jp = new JPanel();

        jp.setBorder(new TitledBorder("Consonanti"));
        jp.setPreferredSize(new Dimension(160, 250));
       //scorre la lista delle lettere e nel caso in cui le lettere siano consonanti
        // le inserisce all'interno del pannello
        for (int i = 0; i < letters.length; i++) {
            // confronta se il tipo di lettera in quella posizione è una vocale
       if(letters[i].getKind()==Letter.CONSONANT) {

            jp.add(letters[i]);
        }
        }

        return jp;
    }
/**
 * Implementa l'azione del pulsante Passa
 * @param e ActionEvent del pulsante Passa
 */
     private void passButton_actionPerformed(ActionEvent e) {
         // imposta il punteggio manche del giocatore in turno a 0
        players.get(player).setManchePoint(0);
        // passa al giocatore successivo
                nextPlayer();
                // abilita il pulsante Gira
                wheelButton.setEnabled(true);
                // disabilita il pulsante passa
                passButton.setEnabled(false);
                // disabilita il pulsante jolly
              jollyButton.setEnabled(false);
     }
     /**
      * Implementa l'azione del pulsante Jolly
      * @param e ActionEvent del pulsante Jolly
      */
     private void jollyButton_actionPerformed(ActionEvent e) {
         // imposta il valore del jolly del giocatore a false in quanto l'ha appena 
         //giocato
         players.get(player).setJollyBoolean(false);
         // abilita il pulsante Gira
                wheelButton.setEnabled(true);
                //disabilita il pulsante passa
                passButton.setEnabled(false);
                // imposta il pulsante del jolly al valore booleano corrispondente
                // al giocatore in corso
                jollyButton.setEnabled(players.get(player).getJollyBoolean());
     }
     /**
      * Implementa l'azione del pulsante Gira
      * @param e ActionEvent del pulsante Gira
      */
     private void wheelButton_actionPerformed(ActionEvent e) {
            //visualizza all'interno del Label il valore della ruota scelto 
         // casualmente dalla lista dei valori
          JWheel.setText(probabilites.get(random.nextInt(probabilites.size())));
          // se il valore prodotto è diverso da jolly o da passa abilita
          // i pulsanti lettera che possono essere scelti
          if(!JWheel.getText().toUpperCase().equals("Jolly".toUpperCase())&&!JWheel.getText().toUpperCase().equals("Passa".toUpperCase())){
        EnabledLetter();
        // disabilita il pulsante gira
        wheelButton.setEnabled(false);
        }else{
              // controlla se il giocatore di turno è in possesso del jolly
              if(players.get(player).getJollyBoolean()){
                // disabilita il pulsante gira
                   wheelButton.setEnabled(false);
                   // abilita il pulsante jolly
                   jollyButton.setEnabled(true);
                   // abilita il pulsante passa
                   passButton.setEnabled(true);
              }
              // controlla se il valore della ruota è uguale a passa
              // se verificato viene controllato successivamente se il giocatore
              // di turno non è in possesso di un jolly. Se questa condizione 
              // è verificata passa il turno al giocatore successivo
              if(JWheel.getText().toUpperCase().equals("Passa".toUpperCase())){
                  if(!players.get(player).getJollyBoolean())
                  nextPlayer();
              }
              
          // controlla che il valore prodotto sia un Jolly.
          // in tal caso viene impostato al giocatore il jolly il quale potrà rigirare
              // la ruota
          if(JWheel.getText().toUpperCase().equals("Jolly".toUpperCase())){
              players.get(player).setJollyBoolean(true);
              
              wheelButton.setEnabled(true);
              jollyButton.setEnabled(false);
               passButton.setEnabled(false);
          }
        }
 
          
          
     }
/**
 * Disabilita la lista delle lettere, sia vocali che consonanti. Viene eseguito ad
 * ogni nuovo turno del giocatore
 */
    public void DisableLetter() {
        for( int i =0;i<letters.length;i++){
            letters[i].setEnabled(false);
        }

    }
 /**
  * Abilita i pulsanti lettera che possono essere giocati dal giocatore di turno
  * nel caso in cui il giocatore sia in possesso di un punteggio manche inferiore a VOWELS_POINT
  * i pulsanti lettera delle vocali non verranno abilitati 
  */
    private void EnabledLetter() {
        // scorre la lista dei giocatori
        for(int i=0; i<players.size();i++){
            // controlla quale giocatore sta giocando in quell'istante
            if(players.get(i).isSelected()){
                // scorre i pulsanti lettera
                for(int j=0;j<letters.length;j++){
                    // verifica che il punteggio di manche di quel giocatore
                    // siamo maggiore o uguale della costante VOWELS_POINT
                    if(players.get(i).getManchePoint()>=VOWELS_POINT ){
                        letters[j].setEnabled(true);
                }else{
                        // controlla che il pulsante lettera in quella posizione sia
                        // una costante. In caso affermativo, il pulsante viene abilitato
                   if(letters[j].getKind()==Letter.CONSONANT){
                       letters[j].setEnabled(true);
                   }     
                }
            }
        }
       
        }
       
        
    }
    /**
     * Disabilita i pulsanti lettera relativi al giocatore di turno
     */
    private void DisabledLetter() {
        for(int i=0; i<players.size();i++){
            if(players.get(i).isSelected()){
                            for( int j =0;j<letters.length;j++){
                letters[j].setEnabled(false);
                    }
             
            }
        }
             
    }
    /**
     * Imposta la frase nascosta attraverso i parametri di input
     * @param phrases Lista di JLabel contenente l'oggetto grafico con la frase nascosta
     * @param Charphrases Lista contenente i singoli caratteri della frase
     */
    public void setPhrases(List <JLabel> phrases,List<Character> Charphrases){
        this.phrases=phrases;
        this.Charphrases=Charphrases;

    }
    /**
     * Imposta i giocatori leggendo i dati dalla lista
     * @param players lista contenente oggetti di tipo Player
     */
    public void setPlayers(List<Player> players){
        this.players=players;
    }
    /**
     * Passa al giocatore successivo. Nel caso in cui il giocatore sia l'ultimo
     * della lista, passa al giocatore primo della lista.
     */
    public void nextPlayer(){
        players.get(player).setSelected(false);
        // controlla che il numero del giocatore della lista coincida con la grandezza
        // della lista. In tal caso viene impostato il valore di indice iniziale della lista
        // in caso contrario viene incrementato di 1 il numero del giocatore
         if(player>=players.size()-1){
                    player=0;
               }else
                   player++;
        // seleziona il giocatore in corso
       players.get(player).setSelected(true);
       // disabilita il pulsante jolly
       jollyButton.setEnabled(false);
       // disabilita il pulsante passa
       passButton.setEnabled(false);
       // se il risultato prodotto dalla ruota è passa disattiva il pulsante jolly
       // e il pulsante passa
       if(JWheel.getText().toUpperCase().equals("Passa".toUpperCase())){
            jollyButton.setEnabled(false);
       passButton.setEnabled(false);
       }
  
    }
    /**
     * Imposta le azioni dei pulsanti lettera
     */
    private void setActionLetters(){
        // scorre l'array dei pulsanti lettera
        for(int i=0;i<letters.length;i++){
            // setta come attivo ogni singolo pulsante
             letters[i].setActive(true);
             // imposta l'azione del pulsante lettera in quella posizione dell'array
            letters[i].addActionListener(new ActionListener() {
                // variabile intera che identifica il punteggio
                private int point;
               
            public void actionPerformed(ActionEvent e) {
                point=0;
                // viene creato e inizializzato un oggetto di tipo Letter
                // attraverso il casting sull'ActionEvent che permette di ritornare
                // l'oggetto che fa riferimento a quell'azione
                Letter letter=(Letter)e.getSource();
                    // controlla che la lettera non sia gia stata giocata
                   if(!letter.isActive()){
                    //controlla se il giocatore non è in possesso di un jolly
                       if(!players.get(player).getJollyBoolean()){
                   wheelButton.setEnabled(true);

                   point=0;
                       }else{

                           wheelButton.setEnabled(false);
                           jollyButton.setEnabled(true);
                           passButton.setEnabled(true);
                       }
                   
               }
               // scorre la lista contenente i singoli caratteri della frase
               for(int i=0; i<Charphrases.size();i++){
                    // Controlla che il carattere in quella posizione sia uguale alla lettera premuta,
                   // che la lettera sia una consonante e che la lettera sia attiva
                   // se la condizione è verifica imposta nella lista JLabel nella posizione di quel carattere
                   // il carattere stesso.
                    if((""+Charphrases.get(i)).equals(letter.getNameLetter())&&letter.getKind()==Letter.CONSONANT&&letter.isActive()){
                        phrases.get(i).setText(""+Charphrases.get(i));
                        wheelButton.setEnabled(true);
                        // viene incrementato un intero che identifica quante lettere uguali sono presenti all'interno della frase
                        point++;
                        // vengono salvate le lettere fino ad ora giocate
                        save.setPhrases(""+Charphrases.get(i));
                      
                    }else{
                        String stringCharacter;
                         // controlla la presenza di lettere accentate
                        // nel caso siano presenti vengono impostate allinterno di
                        // una variabile temporanea il rispettivo valore non accentato
                        // questa condizione si verifica solo per le vocali
                        // in caso di default vengono inserite tutte le altre lettere
                         switch(Charphrases.get(i)){
                               case 'À': 
                                stringCharacter="A";
                               break;
                               case 'È': 
                                stringCharacter="E";
                               break;
                               case 'É': 
                                stringCharacter="E";
                               break;
                               case 'Ì': 
                                stringCharacter="I";
                               break;
                               case 'Ò': 
                                stringCharacter="O";
                               break;
                               case 'Ù': 
                                stringCharacter="U";
                               break;
                               default: 
                                   stringCharacter= ""+Charphrases.get(i);
                                   
                           }
                    // Controlla che il carattere in quella posizione sia uguale alla lettera premuta,
                   // che la lettera sia una vocale e che la lettera sia attiva
                   // se la condizione è verifica imposta nella lista JLabel nella posizione di quel carattere
                   // il carattere stesso.
                        if((""+stringCharacter).equals(letter.getNameLetter())&&letter.getKind()==Letter.VOWEL&&letter.isActive()){   
                            
                            
                        phrases.get(i).setText(""+Charphrases.get(i));    
                        
                        wheelButton.setEnabled(true);
                        // viene impostato -1 per poter determinare la situazione di una lettera vocale
                        point=-1;
                        // vengono salvate le lettere fino ad ora giocate
                        save.setPhrases(""+Charphrases.get(i));
                       
                    }
                    }
                   
                 
                    
               }
                // se point è uguale a -1(condizione in cui si è giocato una lettera vocale)
                //viene sottrato al valore di manche attuale del giocatore, il valore
                // della costante VOWELS_POINT
               if(point==-1){
                    players.get(player).setManchePoint(players.get(player).getManchePoint()-VOWELS_POINT);
               }
                // Condizione che verifica se point è uguale a 0 (condizione in cui la lettera scelta non è 
                // presente all'interno della frase nascosta)
               if(point==0){
                       // Condizione che verifica se il giocatore è in possesso del jolly
                   // in caso affermativo viene attivato il pulsante jolly e il pulsante passa
                   // in caso negativo viene azzerato il valore di manche del giocatore
                   // viene passato il turno al giocatore successivo e viene impostato attivo 
                   // il pulsante per girare la ruota
                    if(players.get(player).getJollyBoolean()){
                       jollyButton.setEnabled(true);
                       passButton.setEnabled(true);
                    }else{
                         players.get(player).setManchePoint(0);
                        nextPlayer();
                        wheelButton.setEnabled(true);
                    }
                    }else{
                    // verifica che l'intero point sia maggiore di 0 e che la lettera sia attiva
                    // in tal caso viene impostato il punteggio di manche moltiplicando il valore uscito dalla ruota,
                    // per il numero di lettere presenti all'interno della frase
                    if(point>0&&letter.isActive())
                   players.get(player).setManchePoint(players.get(player).getManchePoint()+point*Integer.parseInt(JWheel.getText()));
               }
                // condizione in cui viene verificato che point sia diverso da 0 e che la 
                // lettera sia attiva. In tal caso viene disattivata la lettera.
               if(point!=0&&letter.isActive()){
                   letter.setActive(false);
                  
               }
            
                 // Carica il metodo che disabilita tutte le lettere  
                DisabledLetter();
              
            }
        });
    }
    }
    /**
     * Imposta l'azione del salvataggio del gioco
     */
     private void initializeSaveGame(){
     savegame.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
               SaveGame_actionPerformed(e);
                
            }

           
        });
 }
     /**
      * Implementa l'azione della voce Salva Gioco del menu
      * @param e ActionEvent che identifica l'azione della voce Salva Gioco
      */
     private void SaveGame_actionPerformed(ActionEvent e) {
      
  // carica il metodo setWheel della classe SaveGame che imposta
         // i valori relativi la pannello WheelPanel, il valore del Label,
         // il valore del pulsante gira, il valore del pulsante Gira, Il valore del pulsante
         // passa e il valore del pulsante Jolly
      save.setWheel(JWheel.getText(), wheelButton.isEnabled(), passButton.isEnabled(), jollyButton.isEnabled());
  
  }
     /**
      * Imposta il valore di turno del giocatore
      * @param player intero che identifica il turno del giocatore
      */
    public void setPlayer(int player){
        this.player=player;
    }
    /**
     * Restituisce un array di tipo Letter contenente i pulsanti lettera
     * @return un array di tipo Letter contenente i pulsanti lettera
     */
    public Letter[] getLetters(){
        return letters;
    }
    /**
     * Imposta il numero di manche attualmente in corso
     * @param game intero che identifica il numero di manche
     */
    public void setGame(int game){
        this.game=game;
    }
    /**
     * Imposta i valori per il salvataggio di una partita
     * @param savegame oggetto di tipo JMenuItem che identifica la voce Salva Partita dal menu a tendina
     * @param save oggetto di tipo SaveGame per il salvataggio della partita
     */
    public void setSaveGame(JMenuItem savegame,SaveGame save){
     
     this.savegame=savegame;
     this.save=save;
     // inizializza il salvataggio della partita
     initializeSaveGame();
 }
    /**
     * Imposta il caricamento delle lettere
     * @param letters oggetto di tipo Stringa contenente la lista delle lettere
     */
    public void loadLetters(String [] letters){
        // scorre la lista letters di tipo Stringa per poi paragonare
        // ogni lettera con il valore di stringa della lista dei pulsanti lettera
        // per poi marcare come gia scelta la lettera.
        for(int i=0;i<letters.length;i++){
            for(int j=0; j<this.letters.length;j++){
               // se la condizione di uguaglianza è verificata il pulsante lettera
                // viene marcato come gia utilizzato
                if(this.letters[j].getText().equals(letters[i])){
                    
                    this.letters[j].setActive(false);
                }
            }
        }
    }
    /**
     * Imposta il valore del pulsante Gira della ruota da un parametro di input di tipo booleano
     * @param b booleano che identifica se il pulsante è attivo o non attivo.
     */
    public void setWheelButton(boolean b ){
         wheelButton.setEnabled(b);
                passButton.setEnabled(false);
                
              jollyButton.setEnabled(false);
   
}
    /**
     * Imposta il valore del pulsante Passa della ruota da un parametro di input di tipo booleano
     * @param b booleano che identifica se il pulsante è attivo o non attivo
     */
 public void setPassButton(boolean b ){
        
                passButton.setEnabled(b);
                
             
}
 /**
  * Imposta il valore del pulsante Jolly della ruota da un parametro di input di tipo booleano
  * @param b booleano che identifica se il pulsante è attivo o non attivo
  */
  public void setJollyButton(boolean b ){
      
                
              jollyButton.setEnabled(b);
   
}
  /**
   * Imposta il valore visualizzato all'interno del JLabel che mostra i valori della ruota
   * @param data Stringa contenente il valore della ruota
   */
  public void setDataWheel(String data){
      JWheel.setText(data);
  }
  /**
   * Restituisce un intero che mostra il numero attuale del giocatore in turno in quel momento
   * @return un intero che identifica il numero attuale del giocatore
   */
  public int getPlayer(){
      return player;
  }
  
  /**
   * metodo che controlla al caricamento di una partita se i 3 pulsanti sono false. 
   * In tal caso vengono abilitati i pulsanti lettera;
   */
  public void verifyLetters(){
      if(!wheelButton.isEnabled())
          EnabledLetter();
  }
}
